// #include "Queue.h"
// using namespace std;

// //初始化
// void QueueInit(Queue*& pq)
// {
//     pq->headptr=pq->tailptr=nullptr;
//     pq->size=0;
// }

// //销毁
// void QueueDestroy(Queue*& pq)
// {
//     assert(pq);
//     QNode* cur=pq->headptr;
//     while(cur)
//     {
//         QNode* next=cur->next;
//         free(cur);
//         cur=next;
//     }
//     pq->headptr=pq->tailptr=nullptr;
//     pq->size=0;
// }

// // 队尾插入
// void QueuePush(Queue*& pq, QueueElement x)
// {
//     assert(pq);
//     QNode* newnode=new QNode;
//     if(!newnode)
//     {
//         cerr<<"new failed"<<endl;
//     }
//     newnode->next=nullptr;
//     newnode->QueueValue=x;
//     if(pq->tailptr==nullptr)
//     {
//         pq->headptr=pq->tailptr=newnode;
//     }
//     else
//     {
//         //原来队尾指针指向新元素
//         pq->tailptr->next=newnode;
//         //更改队尾指针的指向
//         pq->tailptr=newnode;
//     }
//     pq->size++;
// }

// // 队头删除
// void QueuePop(Queue*& pq)
// {
//     assert(pq&&pq->size);
//     if(pq->headptr->next==nullptr)
//     {
//         free(pq->headptr);
//         pq->headptr=pq->tailptr=nullptr;
//     }
//     else
//     {
//         QNode* next=pq->headptr->next;
//         free(pq->headptr);
//         pq->headptr=next;
//     }
//     pq->size--;
// }

// // 取队头和队尾的数据
// QueueElement QueueFront(Queue* pq)
// {
//     assert(pq);
//     return pq->headptr->QueueValue;
// }

// QueueElement QueueBacindex(Queue* pq)
// {
//     assert(pq);
//     return pq->tailptr->QueueValue;
// }

// //队列中的数据个数
// int QueueSize(Queue* pq)
// {
//     assert(pq);
//     return pq->size;
// }

// //判断队列是否为空
// bool QueueEmpty(Queue* pq)
// {
//     assert(pq);
//     return pq->size==0;
// }

// //输出队列元素
// void QueuePrint(Queue* pq)
// {
//     assert(pq);
//     QNode*cur=pq->headptr;
//     while(cur)
//     {
//         cout<<cur->QueueValue;
//         cur=cur->next;
//     }
//     cout<<endl;
// }


// void test()
// {
//     Queue* q=nullptr;
//     QueueInit(q);
//     QueuePush(q,1);
//     QueuePush(q,2);
//     QueuePush(q,3);
//     QueuePush(q,4);
//     QueuePush(q,5);
//     // cout<<q->size<<endl;
//     cout<<"hello";
// }

// // int main()
// // {
// //     test();
// //     // for(int i=0;i<10;i++)
// //     // {
// //     //     i+=1;
// //     //     [i]()
// //     //     {
// //     //         cout<<i<<"i"<<endl;
// //     //     }
// //     //     ();
// //     // }
// //     cout<<"hello";
// //     return 0;
// // }

// #include <iostream>
// #include <algorithm>
// using namespace std;
// // #define int long long
// const int N=10+20;

// bool visit[N]={false};
// int n;//飞机数量

// struct plane
// {
//   int t,d,l;//到达时间，滞留时间，降落时间
// }p[N];


// //time降落到地面的时间
// bool dfs(int u,int time)
// {
//   if(u>=n)return true;
//   for(int i=0;i<n;i++)
//   {
//     if(!visit[i])
//     {
//       visit[i]=true;
//       if(p[i].t+p[i].d<time)
//       {
//         visit[i]=false;
//         return false;
//       }
//       //计算飞机可以在空中滞留的最大时间
//       int t=max(p[i].t,time)+p[i].l;
//       if(dfs(u+1,t))return true;
//       //这个方案是找一个可行的方案，一旦有一个方案不可行，就切换到另一个状态
//       visit[i]=false;
//     }
//   }
//   return false;
// }

// void solve()
// {
//   cin>>n;
//   for(int i=0;i<n;i++)cin>>p[i].t>>p[i].d>>p[i].l;
//   if(dfs(0,0))cout<<"YES"<<endl;
//   else cout<<"NO"<<endl;
//   for(int i=0;i<n;i++)visit[i]=false;
// }

// // signed main()
// // {
// //   ios::sync_with_stdio(0);
// //   cin.tie(0);
// //   int T;
// //   cin>>T;
// //   while(T--)solve();
// // }
// #include <string>
// // int main()
// // {
// //     string s1("abcd");
// //     string s2=s1.substr(0,2);
// //     cout<<s2;
// //     return 0;
// // }
// #include <iostream>
// #include <string>
// void solve(string s1,string s2)
// {
//     if(s1.size()>0)
//     {
//         char ch=s2[s2.size()-1];
//         cout<<ch;
//         int index=s1.find(ch);
//         solve(s1.substr(0,index),s2.substr(0,index));
//         solve(s1.substr(index+1),s2.substr(index,s1.size()-index-1));
//     }
// }
// #include <bits/stdc++.h>
// // class Solution
// // {
// // public:
// //     int lengthOfLongestSubstring(string s) {
// //         unordered_map<char,int> cimap;
// //         int maxlength=0,left=0,right=0;
// //         for(right=0;right<s.size();right++)
// //         {
// //             //判断当前字符是否为字符串末尾
// //             if(cimap.find(s[right])!=cimap.end())
// //             {
// //                 left=max(left,cimap[s[right]]+1);
// //             }
// //             //将字符加入映射
// //             cimap[s[right]]=right;
// //             maxlength=max(maxlength,right-left+1);
// //         }
// //         int max=right-left;
// //         if(max>maxlength)maxlength=max;
// //         return maxlength;
// //     }
// // };
// // int main()
// // {
// //     // string s1,s2;
// //     // cin>>s1;cin>>s2;
// //     // solve(s1,s2);
// //     // cout<<endl;
// //     // return 0;
// //     string s1;
// //     cin>>s1;
// //     cout<<Solution().lengthOfLongestSubstring(s1);
// // }
// int Binary_search(vector<int> nums,int target)
// {
//     int left=0,right=nums.size()-1;
//     while(left<=right)
//     {
//         int mid=left+(right-left)/2;
//         if(nums[mid]>target)//left,mid,right
//             right=mid-1;
//         else if(nums[mid]<target)
//             left=mid+1;//3
//         else break;
//     }
//     return left;
// }
// class Solution {
// public:
//     vector<int> searchRange(vector<int>& nums, int target) {
//         vector<int> num(2);
//         int start=Binary_search(nums,target);
//         if(start==-1)
//         {
//             num[0]=num[1]=-1;
//             return num;
//         }
//         int end=Binary_search(nums,target+1)-1;
//         num[0]=start,num[1]=end;
//         return num;
//     }
// };
// // int main()
// // {
// //     vector<int> nums={5,7,7,8,8,10};
// //     int target;cin>>target;
// //     vector<int> num=Solution().searchRange(nums,target);
// //     for(auto i:num)cout<<i<<" ";
// //     return 0;
// // }

#include <bits/stdc++.h>
using namespace std;
#include <vector>  
#include <algorithm>  

using namespace std;  

class Solution {  
public:  
    void Heapify(vector<double>& nums, int n, int parent) {  
        int child = parent * 2 + 1;  
        while (child < n) {  
            if (child + 1 < n && nums[child] < nums[child + 1]) {  
                child++;  
            }  
            if (nums[parent] < nums[child]) {  
                swap(nums[parent], nums[child]);  
                parent = child;  
                child = parent * 2 + 1;  
            } else {  
                break;  
            }  
        }  
    }  

    void createHeap(vector<double>& nums) {  
        int n = nums.size();  
        for (int i = (n - 2) / 2; i >= 0; i--) {  
            Heapify(nums, n, i);  
        }  
    }  

    int halveArray(vector<int>& nums) {  
        int count = 0;  
        double sum = 0.0;  
        for (int num : nums) sum += num;  

        double target = sum / 2.0;  
        vector<double> heap(nums.begin(), nums.end());  
        createHeap(heap);  

        while (sum > target) {  
            double maxElement = heap[0];  
            double reducedValue = maxElement / 2.0;  
            sum -= reducedValue; // Reduce the overall sum by halving the maximum  
            heap[0] = maxElement - reducedValue; // Update the heap with the new value  
            createHeap(heap); // Re-heapify after modifying the root  
            count++;  
        }  
        return count;  
    }  
};
int main()
{
    // vector<int> nums={5,19,8,1};
    // cout<<Solution().halveArray(nums);
    int s=1;
    cout<<static_cast<int>(*((char*)&s))<<endl;
    return 0;
}